﻿// Autore: Mattia Barrasso

using System;
using NUnit.Framework;
using RecipesManager.Data;
using TechTalk.SpecFlow;
using White.Core.UIItems;
using White.Core.UIItems.WindowItems;

namespace RecipesManager.Specs.Lista_della_spesa
{
    [Binding, Scope(Feature = "AggiuntaElemento")]
    class AggiuntaElemento : ListaSpesaBdd
    {
        Window _dialog;
        Button _confirm;
        Button _cancel;
        Button _deleteIngredient;

        void getConfirmDialogUi()
        {
            _dialog = MainWindow.ModalWindows()[0];
            _confirm = MainWindow.Get<Button>("6");
            _cancel = MainWindow.Get<Button>("7");
        }

        [BeforeScenario]
        public new void SetUpScenario()
        {
            base.SetUpScenario();
        }

        [AfterScenario]
        public new void TearDownScenario()
        {
            base.TearDownScenario();
        }        
    
        [Given(Regex = "l'ingrediente \"([a-zA-Z ]+)\" esiste")]
        public void DatoIngredienteEsistente(string ingrediente)
        {
            Manager.Ingredients.Add(ingrediente, MeasureType.Weight);
        }
        [Given(Regex = "sono presenti in lista ([0-9]+) \"([a-zA-Z ]+)\" di \"([a-zA-Z ]+)\"")]
        public void DatoIngredientePresenteInLista(int quantità, string unità, string ingrediente)
        {
            Manager.ShoppingList.Add(ingrediente, unità, quantità);
        }

        [Given(Regex = "esiste il negozio \"([a-zA-Z ]+)\"")]
        public void DatoNegozioEsistente(string negozio)
        {
            Manager.Shops.Add(negozio);
        }

        [Given(Regex = "l'ingrediente \"([a-zA-Z ]+)\" è venduto nel negozio \"([a-zA-Z ]+)\" ed è consigliato")]
        public void DatoIngredienteDisponibileEConsigliato(string ingrediente, string negozio)
        {
            Manager.Shops[negozio].IngredientRatings.Add(ingrediente, ShopRating.Good);
        }

        [Given(Regex = "l'ingrediente \"([a-zA-Z ]+)\" è venduto nel negozio \"([a-zA-Z ]+)\"")]
        public void DatoIngredienteDisponibile(string ingrediente, string negozio)
        {
            Manager.Shops[negozio].IngredientRatings.Add(ingrediente, ShopRating.Bad);
        }

        [Given(Regex = "ho inserito i valori")]
        public void DatoInseritoValori(Table table)
        {
            if (!MainWindow.Title.Equals(ShoplistManagerTitle)){
                NavigateToShopList();
                GetShopListUi();
                AddShoppingItem.Click();
                GetSingleShoppingIngredientUi();
            }else
            {
                RefreshSingleShoppingIngredientUi();
            }
            foreach (var row in table.Rows)
            {
                if(row["Attributi"].Equals("Nome"))
                {
                    Assert.That(Ingredients.Items.Exists(item => item.Text.Equals(row["Valori"])));
                    Ingredients.Click();
                    Ingredients.Select(row["Valori"]);
                    
                }else if(row["Attributi"].Equals("Quantità"))
                {
                    if (row["Valori"].Equals("MAX"))
                    {
                        Quantity.SetValue(Double.MaxValue+1);
                    }
                    else
                    {
                        Quantity.SetValue(row["Valori"]);
                    }
                }else if(row["Attributi"].Equals("Unità"))
                {
                    Assert.That(Manager.Measures.Contains(row["Valori"]));
                    CapacityMeasures.Click();
                    Assert.That(CapacityMeasures.Items.Exists(item => item.NameMatches(row["Valori"])));
                    Assert.That(CapacityMeasures.Items.Exists(item => item.Text.Equals(row["Valori"])));
                    /*for (int i = 0; i < CapacityMeasures.Items.Count; i++)
                    {
                        if (!CapacityMeasures.Items[i].Text.Equals(row["Valori"])) continue;
                        string text = CapacityMeasures.Items[i].Text;
                        CapacityMeasures.Click();
                        CapacityMeasures.SetValue(text);
                        break;
                    }*/
                    CapacityMeasures.Click();
                    CapacityMeasures.SetValue(row["Valori"]);
                }else
                {
                    Assert.Fail();
                }
            }
        }

        [When(Regex = "salvo")]
        public void QuandoSalvo()
        {
            Assert.That(Save.Enabled);
            Save.Click();
        }

        [When(Regex = "chiudo")]
        public void QuandoChiudo()
        {
            Close.Click();
        }

        [When(Regex = "seleziono l'ingrediente \"([a-zA-Z ]+)\"")]
        public void QuandoSeleziono(string ingrediente)
        {
            if (!MainWindow.Title.Equals(ShoplistManagerTitle))
            {
                NavigateToShopList();
                GetShopListUi();
                SelectItem(ingrediente);
                RefreshSingleShoppingIngredientUi();
                //GetSingleShoppingIngredientUi();
            }else
            {
                SelectItem(ingrediente);
            }
        }

        [When(Regex = "rimuovo l'elemento")]
        public void QuandoRimuovo()
        {
            RemoveShoppingItem.Click();
            getConfirmDialogUi();
            _confirm.Click();
        }

        [Then(Regex = "nella scheda appaiono (.*) \"([a-zA-Z ]+)\"")]
        public void AlloraNellaSchedaAppare(double valore, string misura)
        {
            RefreshSingleShoppingIngredientUi();
            Assert.That(Math.Abs(Double.Parse(Quantity.Text) - valore) < 0.005);
            //Assert.That(CapacityMeasures.SelectedItem.Text.Equals(misura));
            //Not enabled

        }

        [Then(Regex = "appare il negozio \"([a-zA-Z ]+)\" ed è consigliato")]
        public void AlloraAppareNegozioConsigliato(string negozio)
        {
            Assert.That(ShopsListContainsSuggested(negozio));
        }

        [Then(Regex = "appare il negozio \"([a-zA-Z ]+)\"")]
        public void AlloraAppareNegozio(string negozio)
        {
            Assert.That(ShopsListContains(negozio));
        }

        [Then(Regex = "l'operazione non ha successo")]
        public void AlloraOperazioneFallisce()
        {
            Assert.That(MainWindow.ModalWindows().Count == 1);
        }

        [Then(Regex = "l'operazione ha successo")]
        public void AlloraOperazioneSuccesso()
        {
            Assert.That(MainWindow.ModalWindows().Count == 0);
        }

        [Then(Regex = "l'ingrediente \"([a-zA-Z ]+)\" non appare in lista")]
        public void AlloraIngredienteNonAppare(string ingrediente)
        {
            Assert.That(!ShoppingListContainsIngredient(ingrediente));
        }

        [Then(Regex = "l'ingrediente \"([a-zA-Z ]+)\" appare in lista")]
        public void AlloraIngredienteAppare(string ingrediente)
        {
            Assert.That(ShoppingListContainsIngredient(ingrediente));
        }

        [Then(Regex = "sono segnati (.*) \"([a-zA-Z ]+)\" di \"([a-zA-Z ]+)\"")]
        [Then("sono segnati (.*) \"(.*)\" di \"(.*)\"")]
        public void AlloraSonoSegnati(Decimal quantità, string unità, string ingrediente)
        {
            Assert.That(ShoppingListContains(ingrediente, quantità+" "+unità));
        }    
    }
}
